package com.zlsy.thread.synchronizedlearing;

/**
 * @author zhouliang
 * @date 2020/03/04
 **/
public class SynchronizedStaticClassStatic implements Runnable {
    // 创建两个不同的Runnable实例
    static SynchronizedStaticClassStatic instance1 = new SynchronizedStaticClassStatic();
    static SynchronizedStaticClassStatic instance2 = new SynchronizedStaticClassStatic();
    /**
     * 加了static 这个lock变成了: Object lock = SynchronizedStaticClassStatic.lock; 类属性
     */
    static Object lock = new Object();

    /**
     * 没加static 则是一个成员属性
     */
    Object lock1 = new Object();

    /**
     * 如果lock是成员属性，这里其实上的是”对象锁“，分别是instance1.lock和instance2.lock，它们分别在堆空间的两个不同的地方，
     * 即不是唯一的。
     * 但如果是lock是类属性的话，因为类属性是所有实例共享的，整个堆里面只有一份，所以说这把锁就是唯一的。
     */


    @Override
    public void run() {
        try {
            method();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void method() throws InterruptedException {
        synchronized (lock1) {
            System.out.println("我是类锁的第一种形式：synchronized修饰类方法，" + Thread.currentThread().getName());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("finished");
    }
}
